#include <assert.h>
#include "sdljeu.h"
#include "jeu.h"
#include "ennemi.h"

const int TAILLE_SPRITE=34;

void sdljeuInit(sdlJeu *pSdlJeu, const int numeroTerrain, const int mode)
{
    int i;
	jeu *pJeu;
	int dimx, dimy;

	pJeu = &(pSdlJeu->jeu);
	/* on choisit le mode de jeu en fonction du paramètre mode */
	if (mode == 2 || mode == 3)
        jeuInit(pJeu, numeroTerrain, mode); /* mode 2 joueurs */
    else
        jeuInit(pJeu, numeroTerrain, 1); /* mode 1 joueur */

	dimx = getTailleX(jeuGetConstTerrainPtr(pJeu));
	dimy = getTailleY(jeuGetConstTerrainPtr(pJeu));
	dimx = dimx * TAILLE_SPRITE;
	dimy = dimy * TAILLE_SPRITE;

	putenv("SDL_VIDEO_WINDOW_POS=center");
	pSdlJeu->surface_ecran = SDL_SetVideoMode(dimx+288, dimy+80, 32, SDL_HWSURFACE);
	assert( pSdlJeu->surface_ecran!=NULL);
	SDL_WM_SetCaption("ChompBombs", NULL );

    pSdlJeu->surface_bombe = (SDL_Surface**)malloc(sizeof(SDL_Surface*)*7);
    for(i = 0; i < 7; i++)
    {
        pSdlJeu->surface_bombe[i] = SDL_load_image("data/bombe.bmp");
        assert(pSdlJeu->surface_bombe[i] != NULL);
    }

    pSdlJeu->surface_ennemi = (SDL_Surface**)malloc(sizeof(SDL_Surface*)*4);
    for(i = 0; i < 3; i++)
    {
        if (pSdlJeu->surface_ennemi != 0)
        {
            pSdlJeu->surface_ennemi[i] = SDL_load_image("data/ennemi.bmp");
        }
    }

	pSdlJeu->mario = SDL_load_image("data/mariob.bmp");
	assert( pSdlJeu->mario!=NULL);

	pSdlJeu->luigi = SDL_load_image("data/luigih.bmp");
	assert( pSdlJeu->luigi!=NULL);

	switch(numeroTerrain)
	{
	    case 1: 	pSdlJeu->surface_mur = SDL_load_image("data/mur2.bmp");
                    pSdlJeu->surface_caisse = SDL_load_image("data/caisse.bmp");
                    break;

	    case 2: 	pSdlJeu->surface_mur = SDL_load_image("data/mur2.bmp");
                    pSdlJeu->surface_caisse = SDL_load_image("data/caisse2.bmp");
                    break;

	    case 3: 	pSdlJeu->surface_mur = SDL_load_image("data/mur.bmp");
                    pSdlJeu->surface_caisse = SDL_load_image("data/caisse4.bmp");
                    break;

	    case 4: 	pSdlJeu->surface_mur = SDL_load_image("data/mur3.bmp");
                    pSdlJeu->surface_caisse = SDL_load_image("data/caisse.bmp");
                    break;

	    case 5: 	pSdlJeu->surface_mur = SDL_load_image("data/mur2.bmp");
                    pSdlJeu->surface_caisse = SDL_load_image("data/caisse3.bmp");
                    break;
	}

	assert( pSdlJeu->surface_mur!=NULL);
	assert( pSdlJeu->surface_caisse!=NULL);

    pSdlJeu->herbe = SDL_load_image("data/herbe.bmp");
	assert( pSdlJeu->herbe!=NULL);

	pSdlJeu->surface_menu = SDL_load_image("data/menu1.bmp");
	assert( pSdlJeu->surface_menu!=NULL);

    pSdlJeu->surface_fond = SDL_load_image("data/fond.bmp");
	assert( pSdlJeu->surface_fond!=NULL);

	pSdlJeu->explh = SDL_load_image("data/explh.bmp");
	assert( pSdlJeu->explh!=NULL);

	pSdlJeu->explb = SDL_load_image("data/explb.bmp");
	assert( pSdlJeu->explb!=NULL);

	pSdlJeu->explg = SDL_load_image("data/explg.bmp");
	assert( pSdlJeu->explg!=NULL);

	pSdlJeu->expld = SDL_load_image("data/expld.bmp");
	assert( pSdlJeu->expld!=NULL);

    pSdlJeu->explhb = SDL_load_image("data/explhb.bmp");
	assert( pSdlJeu->expld!=NULL);

	pSdlJeu->explgd = SDL_load_image("data/explgd.bmp");
	assert( pSdlJeu->expld!=NULL);

    pSdlJeu->iconemario = SDL_load_image("data/iconemario.bmp");
	assert( pSdlJeu->iconemario!=NULL);

    pSdlJeu->iconecoeur = SDL_load_image("data/iconecoeur.bmp");
	assert( pSdlJeu->iconecoeur!=NULL);

    pSdlJeu->iconebombe = SDL_load_image("data/iconebombe.bmp");
	assert( pSdlJeu->iconebombe!=NULL);

    pSdlJeu->iconepuiss = SDL_load_image("data/iconepuiss.bmp");
	assert( pSdlJeu->iconepuiss!=NULL);

    pSdlJeu->iconeluigi = SDL_load_image("data/iconeluigi.bmp");
	assert( pSdlJeu->iconeluigi!=NULL);

    pSdlJeu->iconeetoile = SDL_load_image("data/iconeetoile.bmp");
	assert( pSdlJeu->iconeetoile!=NULL);
}

void sdlEtatAffiche(sdlJeu* pSdlJeu, const int mode)
{
    int l = 34;
    int d = 659;
    int h = 70;
    int mc = pSdlJeu->jeu.mario.tabBonus[0];
    int mb = pSdlJeu->jeu.mario.tabBonus[1];
    int lc = pSdlJeu->jeu.luigi.tabBonus[0];
    int lb = pSdlJeu->jeu.luigi.tabBonus[1];

    SDL_apply_surface(pSdlJeu->iconemario, pSdlJeu->surface_ecran, 38, h - 34);

	if (mode == 2 || mode == 3)
    {
        SDL_apply_surface(pSdlJeu->iconeluigi, pSdlJeu->surface_ecran, d + 38, h - 34);

        if (pSdlJeu->jeu.luigi.tabBonus[3] == 1)
        {
            SDL_apply_surface(pSdlJeu->iconepuiss, pSdlJeu->surface_ecran, d + 55, 140 + 2*l);
        }
        if (lc < 4)
        {
            while (lc > 0)
            {
                SDL_apply_surface(pSdlJeu->iconecoeur, pSdlJeu->surface_ecran, d + 21 + (lc-1)*l, 140);
                lc--;
            }
        }
        else
        {
            SDL_apply_surface(pSdlJeu->iconeetoile, pSdlJeu->surface_ecran, d + 55, 140 + 3*l);
        }
        while (lb > 0)
        {
            SDL_apply_surface(pSdlJeu->iconebombe, pSdlJeu->surface_ecran, d + 18 + (lb-1)*l, 140 + l);
            lb--;
        }
    }
    if (pSdlJeu->jeu.mario.tabBonus[3] == 1)
    {
        SDL_apply_surface(pSdlJeu->iconepuiss, pSdlJeu->surface_ecran, 55, 140 + 2*l);
    }
    if(mc < 4)
    {
        while (mc > 0)
        {
            SDL_apply_surface(pSdlJeu->iconecoeur, pSdlJeu->surface_ecran, 21 + (mc-1)*l, 140);
            mc--;
        }
    }
    else
    {
        SDL_apply_surface(pSdlJeu->iconeetoile, pSdlJeu->surface_ecran, 55, 140 + 3*l);
    }
    while (mb > 0)
    {
        SDL_apply_surface(pSdlJeu->iconebombe, pSdlJeu->surface_ecran, 18 + (mb-1)*l, 140 + l);
        mb--;
    }
}

void sdlBombeAffiche(sdlJeu* pSdlJeu, const int i)
{
    if (pSdlJeu->jeu.ter.bombeTab[i] != 0)
    {
        int bombeX = bombeGetX(pSdlJeu->jeu.ter.bombeTab[i])*TAILLE_SPRITE;
        int bombeY = bombeGetY(pSdlJeu->jeu.ter.bombeTab[i])*TAILLE_SPRITE;

        SDL_apply_surface(pSdlJeu->surface_bombe[i], pSdlJeu->surface_ecran, 144 + bombeGetX(pSdlJeu->jeu.ter.bombeTab[i])*TAILLE_SPRITE,  57 + bombeGetY(pSdlJeu->jeu.ter.bombeTab[i])*TAILLE_SPRITE);
        if (pSdlJeu->jeu.tempsBombe - bombeGetHeureInit(pSdlJeu->jeu.ter.bombeTab[i]) >= 0)
        {
            SDL_FreeSurface(pSdlJeu->surface_bombe[i]);
            pSdlJeu->surface_bombe[i] = SDL_load_image("data/bombe.bmp");
        }
        if (pSdlJeu->jeu.tempsBombe - bombeGetHeureInit(pSdlJeu->jeu.ter.bombeTab[i]) >= 250000)
        {
            SDL_FreeSurface(pSdlJeu->surface_bombe[i]);
            pSdlJeu->surface_bombe[i] = SDL_load_image("data/bombe1.bmp");
        }
        if (pSdlJeu->jeu.tempsBombe - bombeGetHeureInit(pSdlJeu->jeu.ter.bombeTab[i]) >= 500000)
        {
            SDL_FreeSurface(pSdlJeu->surface_bombe[i]);
            pSdlJeu->surface_bombe[i] = SDL_load_image("data/bombe2.bmp");
        }
        if (pSdlJeu->jeu.tempsBombe - bombeGetHeureInit(pSdlJeu->jeu.ter.bombeTab[i]) >= 750000)
        {
            SDL_FreeSurface(pSdlJeu->surface_bombe[i]);
            pSdlJeu->surface_bombe[i] = SDL_load_image("data/bombe3.bmp");
        }
        if (pSdlJeu->jeu.tempsBombe - bombeGetHeureInit(pSdlJeu->jeu.ter.bombeTab[i]) >= 1000000)
        {
            SDL_FreeSurface(pSdlJeu->surface_bombe[i]);
            pSdlJeu->surface_bombe[i] = SDL_load_image("data/explx.bmp");

            if (pSdlJeu->jeu.ter.bombeTab[i]->puissance == 1)
            {
                if (pSdlJeu->jeu.ter.terrainTab[(bombeY/TAILLE_SPRITE)-1][bombeX/TAILLE_SPRITE] != '#')
                    {
                        SDL_apply_surface(pSdlJeu->explhb, pSdlJeu->surface_ecran, 144 + bombeX, 57 + bombeY - TAILLE_SPRITE);

                        if (pSdlJeu->jeu.ter.terrainTab[(bombeY/TAILLE_SPRITE)-2][bombeX/TAILLE_SPRITE] != '#')
                            SDL_apply_surface(pSdlJeu->explh, pSdlJeu->surface_ecran, 144 + bombeX,  57 + bombeY - 2*TAILLE_SPRITE);
                    }

                if (pSdlJeu->jeu.ter.terrainTab[(bombeY/TAILLE_SPRITE)+1][bombeX/TAILLE_SPRITE] != '#')
                    {
                        SDL_apply_surface(pSdlJeu->explhb, pSdlJeu->surface_ecran, 144 + bombeX,  57 + bombeY + TAILLE_SPRITE);

                        if (pSdlJeu->jeu.ter.terrainTab[(bombeY/TAILLE_SPRITE)+2][bombeX/TAILLE_SPRITE] != '#')
                            SDL_apply_surface(pSdlJeu->explb, pSdlJeu->surface_ecran, 144 + bombeX, 57 + bombeY + 2*TAILLE_SPRITE);
                    }

                if (pSdlJeu->jeu.ter.terrainTab[bombeY/TAILLE_SPRITE][(bombeX/TAILLE_SPRITE)-1] != '#')
                    {
                        SDL_apply_surface(pSdlJeu->explgd, pSdlJeu->surface_ecran, 144 + bombeX - TAILLE_SPRITE, 57 + bombeY);

                        if (pSdlJeu->jeu.ter.terrainTab[bombeY/TAILLE_SPRITE][(bombeX/TAILLE_SPRITE)-2] != '#')
                            SDL_apply_surface(pSdlJeu->explg, pSdlJeu->surface_ecran, 144 + bombeX - 2*TAILLE_SPRITE,  57 + bombeY);
                    }

                if (pSdlJeu->jeu.ter.terrainTab[bombeY/TAILLE_SPRITE][(bombeX/TAILLE_SPRITE)+1] != '#')
                    {
                        SDL_apply_surface(pSdlJeu->explgd, pSdlJeu->surface_ecran, 144 + bombeX + TAILLE_SPRITE, 57 + bombeY);

                        if (pSdlJeu->jeu.ter.terrainTab[bombeY/TAILLE_SPRITE][(bombeX/TAILLE_SPRITE)+2] != '#')
                            SDL_apply_surface(pSdlJeu->expld, pSdlJeu->surface_ecran, 144 + bombeX + 2*TAILLE_SPRITE,  57 + bombeY);
                    }
            }

            else
            {
                if (pSdlJeu->jeu.ter.terrainTab[(bombeY/TAILLE_SPRITE)-1][bombeX/TAILLE_SPRITE] != '#')
                    SDL_apply_surface(pSdlJeu->explh, pSdlJeu->surface_ecran, 144 + bombeX, 57 + bombeY - TAILLE_SPRITE);

                if (pSdlJeu->jeu.ter.terrainTab[(bombeY/TAILLE_SPRITE)+1][bombeX/TAILLE_SPRITE] != '#')
                    SDL_apply_surface(pSdlJeu->explb, pSdlJeu->surface_ecran, 144 + bombeX, 57 + bombeY + TAILLE_SPRITE);

                if (pSdlJeu->jeu.ter.terrainTab[bombeY/TAILLE_SPRITE][(bombeX/TAILLE_SPRITE)-1] != '#')
                    SDL_apply_surface(pSdlJeu->explg, pSdlJeu->surface_ecran, 144 + bombeX - TAILLE_SPRITE,  57 + bombeY);

                if (pSdlJeu->jeu.ter.terrainTab[bombeY/TAILLE_SPRITE][(bombeX/TAILLE_SPRITE)+1] != '#')
                    SDL_apply_surface(pSdlJeu->expld, pSdlJeu->surface_ecran, 144 + bombeX + TAILLE_SPRITE,  57 + bombeY);
            }
        }
    }
}

void sdljeuAff(sdlJeu *pSdlJeu, const int mode)
{
	int x, y;
    int j = 0;
    int i = 0;
	const terrain *pTer = jeuGetConstTerrainPtr(&(pSdlJeu->jeu));
	const mario *pMar = jeuGetConstMarioPtr(&(pSdlJeu->jeu));
	const mario *pLui = 0;

	if (mode == 2 || mode == 3)
    {
        pLui = jeuGetConstLuigiPtr(&(pSdlJeu->jeu));
    }

	/*Fond de l'écran */
    SDL_apply_surface(pSdlJeu->surface_fond, pSdlJeu->surface_ecran, 0, 0);

    /* Copier les sprite du terrain sur l'écran */
	for (y=0;y<getTailleY(pTer);++y)
		for (x=0;x<getTailleX(pTer);++x)
			{
			    switch(terrainGetXY(pTer,x,y))
			    {
			        case '#':   SDL_apply_surface(pSdlJeu->surface_mur, pSdlJeu->surface_ecran, 144 + x*TAILLE_SPRITE, 57 + y*TAILLE_SPRITE);
                                break;
                    case 'C':   SDL_apply_surface(pSdlJeu->surface_caisse, pSdlJeu->surface_ecran, 144 + x*TAILLE_SPRITE, 57 + y*TAILLE_SPRITE);
                                break;
                    case '.':   SDL_apply_surface(pSdlJeu->herbe, pSdlJeu->surface_ecran, 144 + x*TAILLE_SPRITE, 57 + y*TAILLE_SPRITE);
                                break;
                }
			}

    /* Copier l'état des joueurs sur l'écran.*/
    sdlEtatAffiche(pSdlJeu, mode);

	/* Copier le sprite de Mario sur l'écran */
	SDL_apply_surface(pSdlJeu->mario, pSdlJeu->surface_ecran, 144 + marioGetX(pMar)*TAILLE_SPRITE,  57 + marioGetY(pMar)*TAILLE_SPRITE );

    /* Copier éventuellement le sprite de Luigi sur l'écran */
    if (mode == 2 || mode == 3)
    {
        SDL_apply_surface(pSdlJeu->luigi, pSdlJeu->surface_ecran, 144 + marioGetX(pLui)*TAILLE_SPRITE,  57 + marioGetY(pLui)*TAILLE_SPRITE );
    }

    /* Copier les sprites des ennemis sur l'écran */

    for (j = 0; j < 3; j++)
    {
        if (pSdlJeu->jeu.ter.ennemiTab[j] != 0)
            SDL_apply_surface(pSdlJeu->surface_ennemi[j], pSdlJeu->surface_ecran, 144 + ennemiGetX(pSdlJeu->jeu.ter.ennemiTab[j])*TAILLE_SPRITE,  57 + ennemiGetY(pSdlJeu->jeu.ter.ennemiTab[j])*TAILLE_SPRITE);
    }

    /* Copier les sprites des bombes sur l'écran */
    for (i = 0; i < 7; i++)
    {
        sdlBombeAffiche(pSdlJeu, i);
    }
}

void sdljeuBoucle(sdlJeu *pSdlJeu, const int mode)
{
    int i = 0;
    int gameover = 0;
    int degatMario = 0;
    int degatLuigi = 0;
    int nbEnnemis = -1;
    char directionMario = 'h';
    char directionLuigi = 'h';
	SDL_Event event;
	int continue_boucle = 1;

	assert(SDL_Flip(pSdlJeu->surface_ecran )!=-1 );

    /* Répétition des touches en fonction de la vitesse de Mario */

	SDL_EnableKeyRepeat(10, 300);

    /* tant que ce n'est pas la fin ... */
    do
    {
        /* if (mode == 2 || mode == 3) */
        continue_boucle = gestionExplosion(&pSdlJeu->jeu, &pSdlJeu->jeu.mario, &pSdlJeu->jeu.luigi, mode);

        if (continue_boucle  == 0)
            gameover = 1;

        deplaceEnnemis(&pSdlJeu->jeu, mode);

        /* invincibilité pour Mario */
        if (pSdlJeu->jeu.mario.tabBonus[4] == 1)
            marioInvincible(&pSdlJeu->jeu, &pSdlJeu->jeu.mario, 10);

        /* invincibilité pour Luigi */
        if (pSdlJeu->jeu.mario.tabBonus[4] == 1 && (mode == 2 || mode == 3))
            marioInvincible(&pSdlJeu->jeu, &pSdlJeu->jeu.luigi, 10);

        nbEnnemis = compteEnnemis(&pSdlJeu->jeu);
        if (nbEnnemis == 0 && mode != 2)
        {
            continue_boucle = 0;
            gameover = 1;
        }

        /* on verifie si Mario s'est fait attaquer par un ennemi */
        for (i = 0; i < 4; i++)
        {
            if (pSdlJeu->jeu.ter.ennemiTab[i] != 0)
            {
                degatMario = gestionDegats(&pSdlJeu->jeu, &pSdlJeu->jeu.mario, i, directionMario);
                switch (degatMario)
                {
                    case 0 : continue_boucle = 0; gameover = 1; break;
                    case 1 : continue_boucle = 1; break;
                    case 2 : continue_boucle = 1; break;
                }
                if (mode == 2 || mode == 3) /* si en plus on est en mode 2 joueurs */
                {
                    degatLuigi = gestionDegats(&pSdlJeu->jeu, &pSdlJeu->jeu.luigi, i, directionLuigi);
                    switch (degatLuigi)
                    {
                        case 0 : continue_boucle = 0; gameover = 1; break;
                        case 1 : continue_boucle = 1; break;
                        case 2 : continue_boucle = 1; break;
                    }
                }
            }
        }

        /* tant qu'il y a des evenements à traiter : cette boucle n'est pas bloquante */
        while (SDL_PollEvent(&event))
        {
            /* Si l'utilisateur a cliqué sur la croix de fermeture */
            if (event.type == SDL_QUIT)
                continue_boucle = 0;
            /* Si l'utilisateur a appuyé sur une touche */
            if (event.type == SDL_KEYDOWN)
            {
                switch (event.key.keysym.sym)
                {
                    /* pour les déplacements de Mario */
                    case SDLK_UP:
                        SDL_FreeSurface(pSdlJeu->mario);
                        pSdlJeu->mario = SDL_load_image("data/marioh.bmp");
                        jeuActionClavier(&(pSdlJeu->jeu), 'h', 1);
                        directionMario = 'h';
                        break;
                    case SDLK_DOWN:
                        SDL_FreeSurface(pSdlJeu->mario);
                        pSdlJeu->mario = SDL_load_image("data/mariob.bmp");
                        jeuActionClavier(&(pSdlJeu->jeu), 'b', 1);
                        directionMario = 'b';
                        break;
                    case SDLK_LEFT:
                        SDL_FreeSurface(pSdlJeu->mario);
                        pSdlJeu->mario = SDL_load_image("data/mariog.bmp");
                        jeuActionClavier(&(pSdlJeu->jeu), 'g', 1);
                        directionMario = 'g';
                        break;
                    case SDLK_RIGHT:
                        SDL_FreeSurface(pSdlJeu->mario);
                        pSdlJeu->mario = SDL_load_image("data/mariod.bmp");
                        jeuActionClavier(&(pSdlJeu->jeu), 'd', 1);
                        directionMario = 'd';
                        break;
                    case ' ':
                        if (mode != 2 && mode != 3)
                            jeuActionClavier(&(pSdlJeu->jeu), 'a', 1);
                       break;
                    case SDLK_RETURN:
                       jeuActionClavier(&(pSdlJeu->jeu), 'a', 1);
                       break;
                    default: break;
                }

                    /* pour les déplacements de Luigi */
                if (mode == 2 || mode == 3)
                {
                    switch (event.key.keysym.sym)
                    {
                         case 'z':
                            SDL_FreeSurface(pSdlJeu->luigi);
                            pSdlJeu->luigi = SDL_load_image("data/luigih.bmp");
                            jeuActionClavier(&(pSdlJeu->jeu), 'h', 2);
                            directionLuigi = 'h';
                            break;
                        case 's':
                            SDL_FreeSurface(pSdlJeu->luigi);
                            pSdlJeu->luigi = SDL_load_image("data/luigib.bmp");
                            jeuActionClavier(&(pSdlJeu->jeu), 'b', 2);
                            directionLuigi = 'b';
                            break;
                        case 'q':
                            SDL_FreeSurface(pSdlJeu->luigi);
                            pSdlJeu->luigi = SDL_load_image("data/luigig.bmp");
                            jeuActionClavier(&(pSdlJeu->jeu), 'g', 2);
                            directionLuigi = 'g';
                            break;
                        case 'd':
                            SDL_FreeSurface(pSdlJeu->luigi);
                            pSdlJeu->luigi = SDL_load_image("data/luigid.bmp");
                            jeuActionClavier(&(pSdlJeu->jeu), 'd', 2);
                            directionLuigi = 'd';
                            break;
                        case ' ':
                           jeuActionClavier(&(pSdlJeu->jeu), 'a', 2);
                           break;
                        default:break;
                    }
                }
            }
        }

        /* on affiche le jeu sur le buffer caché */
        sdljeuAff(pSdlJeu, mode);

        /* on permute les deux buffers (cette fonction ne doit se faire qu'une seule fois dans la boucle) */
        SDL_Flip(pSdlJeu->surface_ecran);

        if (gameover == 1) continue_boucle = 0;
    }
    while (continue_boucle == 1);
    sdlgameover(pSdlJeu, mode);
}

int sdlMenuPrincipal(sdlJeu *pSdlJeu)
{
    SDL_Event event;
    int choix = 1;
    int continue_boucle = 1;

    assert(SDL_Flip(pSdlJeu->surface_ecran )!=-1 );
    while (continue_boucle == 1)
    {
        while (SDL_PollEvent(&event))
        {
            if (event.type == SDL_QUIT)
            {
                choix = 0;
                continue_boucle = 0;
            }

            switch (choix)
            {
                case 1: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menu1.bmp"); break;
                case 2: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menu2.bmp"); break;
                case 3: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menu3.bmp"); break;
            }

            /* Si l'utilisateur a appuyé sur une touche */
            if (event.type == SDL_KEYDOWN)
            {
                switch (event.key.keysym.sym)
                {
                    case SDLK_UP: if (choix > 0 && choix <= 3) choix--; break;
                    case SDLK_DOWN: if (choix >= 0 && choix < 3)choix++; break;
                    case SDLK_RETURN: return choix; break;
                    default: break;
                }
            }
        }
        SDL_apply_surface(pSdlJeu->surface_menu, pSdlJeu->surface_ecran, 0, 0);
        SDL_Flip(pSdlJeu->surface_ecran);
    }
	return choix;
}

void sdlgameover(sdlJeu* pSdlJeu, const int mode)
{
    pSdlJeu->gameover = SDL_load_image("data/gameover.bmp");
    if (mode == 2)
    {
        /* on est mode versus : si c'est mario qui est mort, c'est luigi qui a gagné */
        if (pSdlJeu->jeu.mario.tabBonus[0] <= 0)
            pSdlJeu->gameover = SDL_load_image("data/fondVictoireLuigi.bmp");
        if (pSdlJeu->jeu.luigi.tabBonus[0] <= 0)
            pSdlJeu->gameover = SDL_load_image("data/fondVictoireMario.bmp");
    }
    else if (compteEnnemis(&pSdlJeu->jeu) == 0)
        pSdlJeu->gameover = SDL_load_image("data/fondReussi.bmp");
    assert( pSdlJeu->gameover != NULL);
    SDL_apply_surface(pSdlJeu->gameover, pSdlJeu->surface_ecran, 0, 0);
    SDL_Flip(pSdlJeu->surface_ecran);
    sleep(3);
	SDL_FreeSurface(pSdlJeu->gameover);
}

int sdlSelectNiveau(sdlJeu *pSdlJeu)
{
    SDL_Event event;
    int choix = 1;
    int continue_boucle = 1;
    assert(SDL_Flip(pSdlJeu->surface_ecran)!=-1 );

    while (continue_boucle == 1)
    {
        while (SDL_PollEvent(&event))
        {
            if (event.type == SDL_QUIT)
            {
                choix = 0;
                continue_boucle = 0;
            }

            switch (choix)
            {
                case 1: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menuNiveau1.bmp"); break;
                case 2: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menuNiveau2.bmp"); break;
                case 3: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menuNiveau3.bmp"); break;
                case 4: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menuNiveau4.bmp"); break;
                case 5: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menuNiveau5.bmp"); break;
                case 6: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menuNiveau6.bmp"); break;
            }

            /* Si l'utilisateur a appuyé sur une touche */
            if (event.type == SDL_KEYDOWN)
            {
                switch (event.key.keysym.sym)
                {
                    case SDLK_UP: if (choix > 0 && choix <= 6) choix--; break;
                    case SDLK_DOWN: if (choix >= 0 && choix < 6)choix++; break;
                    case SDLK_RETURN: return choix; break;
                    default: break;
                }
            }
        }
        SDL_apply_surface(pSdlJeu->surface_menu, pSdlJeu->surface_ecran, 0, 0);
        SDL_Flip(pSdlJeu->surface_ecran);
    }
	return choix;
}

int sdlSelectModeDeuxJoueurs(sdlJeu *pSdlJeu)
{
    SDL_Event event;
    int choix = 1;
    int continue_boucle = 1;
    assert(SDL_Flip(pSdlJeu->surface_ecran)!=-1 );

    while (continue_boucle == 1)
    {
        while (SDL_PollEvent(&event))
        {
            if (event.type == SDL_QUIT)
            {
                choix = 0;
                continue_boucle = 0;
            }

            switch (choix)
            {
                case 1: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menuversus.bmp"); break;
                case 2: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menucoop.bmp"); break;
                case 3: SDL_FreeSurface(pSdlJeu->surface_menu); pSdlJeu->surface_menu = SDL_load_image("data/menu2quit.bmp"); break;
            }

            /* Si l'utilisateur a appuyé sur une touche */
            if (event.type == SDL_KEYDOWN)
            {
                switch (event.key.keysym.sym)
                {
                    case SDLK_UP: if (choix > 0 && choix <= 3) choix--; break;
                    case SDLK_DOWN: if (choix >= 0 && choix < 3)choix++; break;
                    case SDLK_RETURN: return choix; break;
                    default: break;
                }
            }
        }
        SDL_apply_surface(pSdlJeu->surface_menu, pSdlJeu->surface_ecran, 0, 0);
        SDL_Flip(pSdlJeu->surface_ecran);
    }
	return choix;
}

void sdljeuDetruit(sdlJeu *pSdlJeu)
{
    int i;
	SDL_FreeSurface(pSdlJeu->mario);
	for (i = 0; i < 3; i++)
        SDL_FreeSurface(pSdlJeu->surface_ennemi[i]);
	SDL_FreeSurface(pSdlJeu->surface_mur);
	SDL_FreeSurface(pSdlJeu->surface_fond);
	SDL_FreeSurface(pSdlJeu->surface_caisse);
	SDL_FreeSurface(pSdlJeu->explh);
    SDL_FreeSurface(pSdlJeu->explb);
	SDL_FreeSurface(pSdlJeu->explg);
	SDL_FreeSurface(pSdlJeu->expld);
	SDL_FreeSurface(pSdlJeu->explhb);
	SDL_FreeSurface(pSdlJeu->explgd);
    SDL_FreeSurface(pSdlJeu->iconebombe);
	SDL_FreeSurface(pSdlJeu->iconemario);
    SDL_FreeSurface(pSdlJeu->iconeluigi);
    SDL_FreeSurface(pSdlJeu->iconepuiss);
    SDL_FreeSurface(pSdlJeu->iconeetoile);
    SDL_FreeSurface(pSdlJeu->iconecoeur);
	SDL_FreeSurface(pSdlJeu->herbe);
    SDL_FreeSurface(pSdlJeu->surface_ecran);
    SDL_FreeSurface(pSdlJeu->surface_menu);
	for (i = 0; i < 4; i++)
        SDL_FreeSurface(pSdlJeu->surface_bombe[i]);
	SDL_Quit();
	jeuLibere(&pSdlJeu->jeu);
}

SDL_Surface *SDL_load_image(const char* filename)
{
	SDL_Surface* loadedImage = NULL;
	SDL_Surface* optimizedImage = NULL;
	loadedImage = SDL_LoadBMP(filename);
	if (loadedImage != NULL)
	{
		optimizedImage = SDL_DisplayFormat(loadedImage);
		SDL_FreeSurface(loadedImage);
	}
	return optimizedImage;
}

void SDL_apply_surface( SDL_Surface* source, SDL_Surface* destination, int x, int y )
{
	SDL_Rect offset;
	offset.x = x;
	offset.y = y;
	SDL_BlitSurface( source, NULL, destination, &offset );
}
